﻿#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<assert.h>
using namespace std;

//class A
//{
//public:
//
//    A(int a = 10)
//        :_a(a)
//    {
//    }
//private:
//    int _a;
//
//};
//
//class B
//{
//public:
//    //初始化列表：对象成员定义的地方
//    B(int a, int ref)      
//        : _ref(ref)
//       /* , _n(10)*/
//    {
//    }
//
//private:
//
//    A _aobj; // 没有默认构造函数    
//
//    //特征：必须在定义的时候初始化 
//    int& _ref; // 引用     
//    const int _n = 10; // const 
//};
//
//int main()
//{
//    //对象整体定义的地方
//    B b1(10, 20);
//
//    return 0;
//}

//class Date
//{
//public:
//	// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
//	// explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
//	/*explicit*/ Date(int year)
//		:_year(year)
//	{
//	}
//	 
//	// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
//	// explicit修饰构造函数，禁止类型转换
//
//	//explicit Date(int year=1000, int month = 1, int day = 1)
//	//: _year(year)
//	//, _month(month)
//	//, _day(day)
//	//{}
//	 
//	Date& operator=(const Date& d)
//	{
//		if (this != &d)
//		{
//			_year = d._year;
//			_month = d._month;
//			_day = d._day;
//		}
//		return *this;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//void Test()
//{
//	Date d1(2022);
//
//	d1 = 2023;
//	// 用一个整形变量给日期类型对象赋值
//	// 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值d1 = 2023;
//    // 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用
//}
//
//int main()
//{
//	Test();
//	return 0;
//}


//class A
//{
//public:
//	A() 
//	{
//		++_scount;
//	}
//
//	A(const A& t) 
//	{
//		++_scount;
//	}
//
//	~A() 
//	{ 
//		--_scount;
//	}
//
//
//	void Func1()
//	{
//		// 非静态能否调用静态：可以
//		GetACount();
//	}
//
//	void Func2()
//	{
//		++_a1;
//	}
//
//	// 没有this指针，指定类域和访问限定符就可以访问
//	static int GetACount() 
//	{ 
//		// 静态能否调用非静态：不可以。非静态的成员函数调用需要this指针，我没有this
//		// Func2();
//
//		//_a1++;
//		return _scount;
//	}
//private:
//	// 成员变量 -- 属于每个一个类对象，存储对象里面
//	int _a1 = 1;
//	int _a2 = 2;
//public:
//	// 静态成员变量 -- 属于类，属于类的每个对象共享，存储在静态区
//	static int _scount;
//};
//
//// 全局位置，类外面定义
//int A::_scount = 1;
//
//A aa0;
//
//void Func()
//{
//	static A aa2;
//	cout << __LINE__ << ":" << aa2.GetACount() << endl;
//
//	// 全局变量的劣势：任何地方都可以随意改变
//	//_scount++;
//}
//
//int main()
//{ 
//	cout << A::_scount;
//	return 0;
//}



// 设计一个类，在类外面只能在栈上创建对象
// 设计一个类，在类外面只能在堆上创建对象

//class A
//{
//public:
//	static A GetStackObj()
//	{
//		A aa;
//		return aa;
//	}
//
//	static A* GetHeapObj()
//	{
//		return new A;
//	}
//
//private:
//	A(int a = 3,int b = 5)
//		:_a(a)
//		,_b(b)
//	{
//
//	}
//
//private:
//	int _a = 1;
//	int _b = 2;
//
//};
//
//int main()
//{
//	 
//	return 0;
//}



//class Time
//{
//    friend class Date;   // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
//
//public:
//    Time(int hour = 0, int minute = 0, int second = 0)
//        : _hour(hour)
//        , _minute(minute)
//        , _second(second)
//    {
//    }
//
//private:
//    int _hour;
//    int _minute;
//    int _second;
//};
//
//class Date
//{
//public:
//    Date(int year = 1900, int month = 1, int day = 1)
//        : _year(year)
//        , _month(month)
//        , _day(day)
//    {
//    }
//
//    void SetTimeOfDate(int hour, int minute, int second)
//    {
//        // 直接访问时间类私有的成员变量
//        _t._hour = hour;
//        _t._minute = minute;
//        _t._second = second;
//    }
//
//private:
//    int _year;
//    int _month;
//    int _day;
//    Time _t;
//};
//
//
//
//class A
//{
//public:
//    A()
//    {
//        h = 10;
//    }
//
//    static void print()
//    {
//
//    }
//
//private:
//    static int k;
//    int h;
//
//
//
//public:
//    class B
//    {
//    public:
//        void foo()
//        {
//            A a;
//            a.print();
//            print();
//            a.h = 10;
//            k = 1;
//        }
//    private:
//        int b;
//    };
//};
//
//int A::k = 1;
//
//int main()
//{
//    cout << sizeof(A) << endl;
//
//    A::B a;
//    
//    
//	return 0;
//}
//

//class Date
//{
//
//	// 友元函数声明
//	friend ostream& operator<<(ostream& out, const Date& d);
//	friend istream& operator>>(istream& in, Date& d);
//
//
//public:
//	Date(int year = 2023, int month = 3, int day = 31)
//		:_year(year)
//		,_month(month)
//		,_day(day)
//	{
//
//	}
//
//
//	int GetMonthDay(int year,int month )
//	{
//		static int daysArr[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
//
//		if ((month == 2) && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
//		{
//			return 29;
//		}
//
//		return daysArr[month];
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//
//
//};
//
//
//ostream& operator<<(ostream& out, const Date& d)
//{
//	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
//
//	return out;
//}
//
//istream& operator>>(istream& in, Date& d)
//{
//	int year, month, day;
//	in >> year >> month >> day;
//
//	if (month > 0 && month < 13
//		&& day > 0 && day <= d.GetMonthDay(year, month))
//	{
//		d._year = year;
//		d._month = month;
//		d._day = day;
//	}
//	else
//	{
//		cout << "非法日期" << endl;
//		assert(false);
//	}
//
//	return in;
//}
//
//
//
//int main()
//{
//	Date d;
//	cout << d;
//	return 0;
//}


//class  A
//{
//	 
//	friend class B;
//public:
//	A( )
//	{
//		 
//
//	}
//
//private:
//	static int a;
//	int b;
//};
//
//class B
//{
//	//friend class A;
//
//public:
//	B(A& d)
//	{
//		cout << d.a;
//		cout << d.b ;
//		d.a = 100;
//		d.a = 200;
//		A::a = 200;
//	}
//private:
//	int d;
//	int c;
//};
//
//int main()
//{
//
//	return 0;
//}


//class A
//{
//private:
//	static int _k;
//	int _h = 1;
//
//
//public:
//	class B // B默认就是A的友元
//	{
//	public:
//		void foo(const A& a)
//		{
//			cout << _k << endl; //OK
//			cout << a._h << endl; //OK
//			cout << A::_k;
//			cout << a._k;
//		}
//		int _b1;
//	};
//
//
//};
//
//int main()
//{
//
//	return 0;
//}

//class Solution {
//
// public:
//    class sum
//    {
//    public:
//        sum()
//        {
//            ret = ret + i;
//            i++;
//
//        }
//    };
//
//public:
//    int Sum_Solution() {
//        sum arr[10];
//        return ret;
//    }
//
//    static int ret;
//    static int i;
//
//};
//
//int Solution::ret = 0;
//int Solution::i = 1;


//class Outer 
//{
//
//public:
//
//    class Inner 
//    {
//        private:
//            int privateVar = 10;
//        public:
//            int publicVar = 20;
//    };
//
//    void accessInner(Inner& a) {
//        Inner inner;
//        inner.publicVar = 30;  // 合法：访问内部类的公有成员
//        //inner.privateVar = 40;  // 错误：无法直接访问内部类的私有成员
//        a.publicVar = 10;
//    }
//};
//
//int main()
//{
//
//    return 0;
//}


//class A
//{
//
//public:
//    A(int a = 0)
//        :_a(a)
//    {
//        cout << "A(int a)" << endl;
//    }
//
//    ~A()
//    {
//        cout << "~A()" << endl;
//    }
//private:
//    int _a;
//
//};
//
//
//class Solution 
//{
//public:
//    int Sum_Solution(int n) {
//        cout << "Sum_Solution" << endl;
//        //...
//        return n;
//    }
//};
//
//
//void push_back(const string & s)
//{
//    cout << "push_back:" << s << endl;
//}
//
//int main()
//{
//    A aa(1);  // 有名对象 -- 生命周期在当前函数局部域
//    A(2);     // 匿名对象 -- 生命周期在当前行
//     
//
//    Solution sl;
//    sl.Sum_Solution(10);
//
//    Solution().Sum_Solution(20);
//
//    //A& ra = A(1);  // 匿名对象具有常性
//    const A& ra = A(1); // const引用延长匿名对象的生命周期，生命周期在当前函数局部域
//     
//
//    string str("11111");
//    push_back(str);
//
//    push_back(string("222222"));
//
//    push_back("222222");
//
//    return 0;
//}



//void Func1(A aa)
//{
//
//}
//
//A Func5()
//{
//    A aa;
//    return aa;
//}
//
//int main()
//{
//    A ra1 = Func5(); // 拷贝构造+拷贝构造 ->优化为拷贝构造
//    cout << "==============" << endl;
//    A ra2;
//    ra2 = Func5();
//
//    A aa1;
//    Func1(aa1); // 不会优化
//
//    Func1(A(1)); // 构造+拷贝构造 ->优化为构造
//    Func1(1);    // 构造+拷贝构造 ->优化为构造
//
//    A aa2 = 1;  // 构造+拷贝构造 ->优化为构造
//
//
//    return 0;
//}



//class A
//{
//public:
//	A(int a = 0)
//		:_a1(a)
//	{
//		cout << "A(int a)" << endl;
//	}
//
//	A(const A& aa)
//		:_a1(aa._a1)
//	{
//		cout << "A(const A& aa)" << endl;
//	}
//
//	A& operator=(const A& aa)
//	{
//		cout << "A& operator=(const A& aa)" << endl;
//		if (this != &aa)
//		{
//			_a1 = aa._a1;
//		}
//		return *this;
//	}
//
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//private:int _a1 = 1;
//
//};

//void f1(A aa)
//{
//
//}
//
//A f2()
//{
//	A aa;
//	return aa;
//}
//
//
//int main()
//{
//	// 传值传参
//	// 构造+拷⻉构造
//	A aa1;
//	f1(aa1);
//	cout << endl;
//	// 隐式类型，连续构造+拷⻉构造->优化为直接构造
//	f1(1);
//	// ⼀个表达式中，连续构造+拷⻉构造->优化为⼀个构造
//	f1(A(2));
//	cout << endl;
//	cout << "***********************************************" << endl;
//	// 传值返回
//	// 不优化的情况下传值返回，编译器会⽣成⼀个拷⻉返回对象的临时对象作为函数调⽤表达式的返回值
//	// ⽆优化 （vs2019 debug）
//	// ⼀些编译器会优化得更厉害，将构造的局部对象和拷⻉构造的临时对象优化为直接构造（vs2022 debug）
//	f2();
//	cout << endl;
//	// 返回时⼀个表达式中，连续拷⻉构造+拷⻉构造->优化⼀个拷⻉构造 （vs2019 debug）
//	// ⼀些编译器会优化得更厉害，进⾏跨⾏合并优化，将构造的局部对象aa和拷⻉的临时对象和接收返回值对象aa2优化为⼀个直接构造。（vs2022 debug）
//	A aa2 = f2();
//	cout << endl;
//	// ⼀个表达式中，开始构造，中间拷⻉构造+赋值重载->⽆法优化（vs2019 debug）
//
//	// ⼀些编译器会优化得更厉害，进⾏跨⾏合并优化，将构造的局部对象aa和拷⻉临时对象合并为⼀个直接构造（vs2022 debug）
//	aa1 = f2();
//	cout << endl;
//	 
//	return 0;
//	  
//}

//int main()
//{
//    //int* a = new int;
//    //delete a;
//
//    //int* a2 = new int[4] {1, 2, 3, 4};
//    //delete [] a2;
//
//    //int* a3 = new int(1);
//    //delete[] a3;
// /*   int* a = nullptr;
//    do
//    {
//        a = (int*)malloc(1024 * 1024);
//        cout << a << endl;
//    } while (a);*/
//
//    int* a = new int;
//    return 0;
//}
//typedef int DataType;
//class Stack
//{
//public:
//	Stack(size_t capacity = 3)
//	{
//		cout << "Stack(size_t capacity = 3)" << endl;
//
//		_array = (DataType*)malloc(sizeof(DataType) * capacity);
//		if (NULL == _array)
//		{
//			perror("malloc申请空间失败!!!");
//			return;
//		}
//
//		_capacity = capacity;
//		_size = 0;
//	}
//
//	void Push(DataType data)
//	{
//		// CheckCapacity();
//		_array[_size] = data;
//		_size++;
//	}
//
//	// 其他方法...
//
//	~Stack()
//	{
//		cout << "~Stack()" << endl;
//
//		if (_array)
//		{
//			free(_array);
//			_array = NULL;
//			_capacity = 0;
//			_size = 0;
//		}
//	}
//
//private:
//	DataType* _array;
//	int       _capacity;
//	int       _size;
//};
//
//int main()
//{
//	//内置类型
//	int* a1 = (int*)malloc(sizeof(int));
//	free(a1);
//
//	int* a2 = new int;//不初始化
//	delete a2;
//
//	int* a3 = new int(1);//初始化
//	delete a3;
//
//	int* a4 = new int[4];//数组~不初始化
//	delete[] a4;
//
//	int* a5 = new int[4] {1, 2, 3, 4};//数组~初始化，不完全初始化的话，未初始化的都会被初始化为0
//	delete[] a5;
//
//
//	//自定义类型~用法和内置类型同理
//	// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数
//
//
//	return 0;
//}

class A
{
public:
    A(int a = 10, int b = 20)
        : _a(a)
        ,_b(b)
    {
        cout << "A(int a)" << endl;
    }

    A(const A& aa)

    {
        cout << "A(const A& aa)" << endl;
    }

    A& operator=(const A& aa)
    {
        cout << "A& operator=(const A& aa)" << endl;

        if (this != &aa)
        {
            _a = aa._a;
        }

        return *this;
    }

    ~A()
    {
        cout << "~A()" << endl;
    }
private:
    int _a;
    int _b;
};

//int main()
//{
//    //A a;
//    //A b = 1;
//
//    //A* a = new A[2]{ A(1,2),A(2,3) };
//    //A* b = (A*)malloc(sizeof(A));
//
//    //free(a);
//    //delete b;
//     
//    /*  int* a = nullptr;
//    do
//    {
//        a = (int*)malloc(1024 * 1024);
//        cout << a << endl;
//
//    } while (a); */
//
//    
//    return 0;
//}

//int main()
//{
//	int* p1 = nullptr;
//	try
//	{
//		do
//		{
//			//p1 = (int*)malloc(1024 * 1024);
//			p1 = new int[1024 * 1024];
//			cout << p1 << endl;
//
//		} while (p1);
//	}
//	catch (const exception& e)
//	{
//		cout << e.what() << endl;
//	}
//
//	return 0;
//}
//
//int main()
//{
//    // p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
//    A* p1 = (A*)malloc(sizeof(A));
//    new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参
//    p1->~A();
//    free(p1);
//
//    A* p2 = (A*)operator new(sizeof(A));
//    new(p2)A(10);
//    p2->~A();
//    operator delete(p2);
//    return 0;
//}


//1、getchar -- 用于从标准输入流（通常是键盘）读取一个字符
//2、getchar 函数没有参数，返回值类型是 int 。
//3、返回读取到的字符的 ASCII 码值 ，如果读取失败或者遇到文件结束符（EOF，通常被定义为 - 1），则返回 EOF
//4、getchar会读取换行符
//int main()
//{
//    int c = 0; 
//    //do {
//    //    c = getchar();
//    //    putchar(c);
//    //    getchar();
//    //} while (c != EOF);
//
//    while (c!= EOF)
//    {
//        c = getchar();        
//        //putchar(c);
//        cout << c <<endl;
//        getchar();
//    }
//    return 0;
//}



// 1. getchar -- 用于从标准输入流（通常是键盘）读取一个字符
// 2. getchar 函数没有参数，返回值类型是 int。
// 3. 返回读取到的字符的 ASCII 码值，如果读取失败或者遇到文件结束符（EOF，通常被定义为 -1），则返回 EOF。
// 4. getchar 会读取换行符，包括用户输入的换行符。
// 5. 注意：必须使用 int 类型变量存储 getchar 的返回值，以正确判断 EOF。

//int main()
//{
//    // 使用 int 类型存储 getchar 的返回值
//    int c = 0;
//
//    // 循环读取字符，直到遇到 EOF
//    while ((c = getchar()) != EOF)
//    {
//        // 输出读取到的字符的 ASCII 码值
//        cout << c << endl;
//
//        // 消耗换行符，避免影响后续输入
//        getchar();
//    }
//
//    // 检查是否是读取错误导致的 EOF
//    if (ferror(stdin))
//    {
//        printf("读取错误！\n");
//    }
//    else 
//    {
//        printf("遇到文件结束符（EOF），程序结束。\n");
//    }
//
//    return 0;
//}


//int main()
//{
//    // 定义变量存储输入值
//    int num;
//    float fnum;
//    char ch;
//
//    // 循环读取数据，直到遇到 EOF
//    while (true)
//    {
//
//        // 读取整数、浮点数和字符
//        int result = scanf("%d %f %c", &num, &fnum, &ch);
//
//        // 检查是否读取失败
//        if (result == EOF)
//        {
//            // 检查是否是读取错误导致的 EOF
//            if (ferror(stdin))
//            {
//                printf("读取错误！\n");
//            }
//            else
//            {
//                printf("遇到文件结束符（EOF），程序结束。\n");
//            }
//            break;
//        }
//
//        // 检查是否成功读取所有参数
//        if (result != 3)
//        {
//            printf("输入格式错误！\n");
//            // 清除输入缓冲区
//            while (getchar() != '\n');
//            continue;
//        }
//
//        // 输出读取到的值
//        cout << "整数: " << num << endl;
//        cout << "浮点数: " << fnum << endl;
//        cout << "字符: " << ch << endl;
//    }
//
//    return 0;
//}

// 1. gets -- 用于从标准输入流（通常是键盘）读取一行字符串
// 2. gets 函数接收一个字符数组作为参数，返回值类型是 char*。
// 3. 返回指向输入字符串的指针，如果读取失败或者遇到文件结束符（EOF），则返回 NULL。
// 4. gets 会读取换行符，但不会将其存储到目标字符串中。
// 5. 注意：gets 函数存在严重的安全问题，可能导致缓冲区溢出，已被 C11 标准废弃，建议使用 fgets 替代。
 
#include <cstdio>
#include <cstring>
using namespace std;

//int main()
//{
//    // 定义字符数组存储输入字符串
//    char buffer[100];
//
//    // 提示用户输入
//    printf("请输入一行文本：");
//
//    // 读取一行文本，最多读取 99 个字符（留一个位置给 '\0'）
//    if (fgets(buffer, sizeof(buffer), stdin) != NULL)
//    {
//        // 移除换行符（如果存在）
//        //buffer[strcspn(buffer, "\n")] = 0;
//
//        // 输出读取到的文本
//        cout << "你输入的文本是：" << buffer << endl;
//    }
//    else
//    {
//        // 检查是否是读取错误导致的 NULL
//        if (ferror(stdin))
//        {
//            printf("读取错误！\n");
//        }
//        else
//        {
//            printf("遇到文件结束符（EOF），程序结束。\n");
//        }
//    }
//
//    return 0;
//}

int main()
{
  /*  char a = 0;
    int b = 0;
    int ret = scanf("%d %c", &b, &a);*/

    char a[] = "abd";
    scanf("%s", a);
    return 0;
}